﻿#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<string>
#include<vector>
using namespace std;

////class Solution {
////public:
////    bool isAnagram(string s, string t) 
////    {
////        if (s.length() != t.length())
////        {
////            return false;
////        }
////        sort(s.begin(), s.end());
////        sort(t.begin(), t.end());
////        return s == t;
////    };
//
//    int main()
//    {
//        string s, t;
//        cin >> s >> t;
//        if (s == t)
//        {
//            cout << '1';
//        }
//        //cout << isAnagram(s, t);
//        return 0;
//    }




//class parent
//{
//public:
//	parent(int _name,int _id)
//		:name(_name)
//		,id(_id)
//	{}
//	~parent()
//	{
//
//	}
//	void a()
//	{
//		cout << "void a()" << name << endl;//可以间接实用基类私有成员
//	}
//protected:
//	int name = 1;
//	int id = 2;
//};
//
//class child : public parent
//{
//public:
//	child(int __name, int __id, int _age) 
//		:parent(__name,__id)
//		,age(_age)
//	{}
//
//	child(const child& c)
//		:parent(c)
//		,age(c.age)
//	{}
//
//	//编译默认生成的就够用
//	//存在深拷贝，则需要自己写
//	/*child& operator=(const child& s)
//	{
//		if (this != &s)
//		{
//		
//		}
//	}*/
//	void write()
//	{
//		cout << name << id << age;
//	}
//protected:
//	int age;
//};
//
//
//int main()
//{
//	child c1(1,2,3);
//	c1.write();
//	child c2(c1);
//	child c3(4, 5, 6);
//	c3 = c1;
//	return 0;
//}





//模板的继承
//template<class T>
//class stack : public vector<T>
//{
//public:
//	void push(const T& x)
//	{
//		vector<T>::push_back(x);//类模板需要指定类域，否则找不到函数
//	}
//};
//
//int main()
//{
//	int a = 1;
//	const double &d = a;//中间创建了临时对象，
//	//临时对象具有常性，常性对象只能赋值给常性对象
//
//	return 0;
//}

//class A
//{
//public:
//	void fun()
//	{
//
//	}
//};
//
//class B : public A
//{
//public:
//	void fun(int a)
//	{
//
//	}
//};
//
//int main()
//{
//	B b;
//	//b.fun();
//	b.fun(1);
//	b.A::fun();
//	return 0;
//}


//友元函数要声明
//class student;
//
//class person
//{
//public:
//	
//	friend void write(const person& p,const student& s);
//
//protected:
//	string name = "张三";
//	int age = 18;
//};
//
//class student : public person
//{                                 
//public:
//	friend void write(const person& p, const student& s);
//protected:
//	int id = 20;
//};
//
//void write(const person& p, const student& s)
//{
//	cout << "名字:" << p.name << endl;
//	cout << "年龄:" << p.age << endl;
//	cout << "id:" << s.id << endl;
//}
//
//
//int main()
//{
//	person p;
//	student s;
//	write(p, s);
//	return 0;
//}



//多继承有二义性，会产生数据冗余
//虚继承 virtual关键字

//class Person
//{
//public:
//	string _name; // 姓名 
//	void Print()
//	{
//		cout << _name << endl;
//	}
//	/*int _tel;
//int _age;
// string _gender;
// string _address;*/
// // ...
//};
//// 使⽤虚继承Person类 
//class Student : virtual public Person
//{
//protected:
//	int _num; //学号 
//};
//// 使⽤虚继承Person类 
//class Teacher : virtual public Person
//{
//protected:
//	int _id; // 职⼯编号 
//};
//// 教授助理 
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程 
//	/*void Print()
//	{
//		cout << _name << endl;
//	}*/
//};
//int main()
//{
//	// 使⽤虚继承，可以解决数据冗余和⼆义性 
//	Assistant a;
//	a._name = "peter";
//	a.Print();
//	return 0;
//}







//多态

//实现多态还有两个必须重要条件：
//• 必须是基类的指针或者引⽤调⽤虚函数
//• 被调⽤的函数必须是虚函数，并且完成了虚函数重写 / 覆盖。



//virtual只有成员函数和基类才有意义
//class Person
//{
//public:
//	virtual void buyticket()
//	{
//		cout << "买票——全价" << endl;
//	}
//};
//
//class Student : public Person
//{
//public:
//	virtual void buyticket()
//	{
//		cout << "买票——打折" << endl;
//	}
//};
//
////指针类型
//void func(Person* p)//基类的指针
//{
//	p->buyticket();
//}
//
////void func(Student* s)
////{
////	s->buyticket();
////}
//
////引用也可以用
//void func(Person& p)//基类的引用
//{
//	p.buyticket();
//}
//
//int main()
//{
//	Person p;
//	Student s;
//	func(&p);
//	func(&s);
//
//	Person p;
//	Student s;
//	func(p);
//	func(s);
//
//	return 0;
//}


//虚函数的作用是：在构成多态时重写虚函数的实现，也就是用基类虚函数的声明+派生类重写的虚函数实现

//class A
//{
//public:
//	virtual void func(int val = 1) { std::cout << "A->" << val << std::endl; }
//	virtual void test() { func(); }
//};
//
//class B : public A
//{
//public:
//	void func(int val = 0) { std::cout << "B->" << val << std::endl; }
//};
//
//int main(int argc, char* argv[])
//{
//	B* p = new B;
//	p->test();
//	p->func();
//	return 0;
//}

//virtual void func(int val = 1) { std::cout << "B->" << val << std::endl; }
//实际函数实现



//协变
//class A {};
//class B : public A {};
//
//class Person {
//public:
//	virtual A* BuyTicket()//A改写成基类名也是正确的
//	{
//		cout << "买票-全价" << endl;
//		return nullptr;
//	}
//};
//
//class Student : public Person {
//public:
//	virtual B* BuyTicket()//B改写成派生类名也是正确的
//	{
//		cout << "买票-打折" << endl;
//		return nullptr;
//	}
//};
//
//void Func(Person* ptr)
//{
//	ptr->BuyTicket();
//}
//
//int main()
//{
//	Person ps;
//	Student st;
//	Func(&ps);
//	Func(&st);
//	return 0;
//}



//虚函数的重写
//多态调用，指向谁，调用谁的析构函数
// 
// delete
//p1->析构函数()跟指向的类型有关 + operator delete(p1)

// 由于多态的调用,虚函数的名称必须相同，所以析构函数都改名为destructor(),也就是构成了隐藏.。
// 如果不正常调用则会出现有的函数未进行析构，就会导致内存泄露。
//p1->destructor()


//class A
//{
//public:
//	virtual ~A()
//	{
//		cout << "~A()" << endl;
//	}
//};
//
//class B : public A {
//public:
//	virtual ~B()//派生类可以不加virtual，但最好还是加上
//	{
//		cout << "~B()->delete:" << _p << endl;
//		delete _p;
//	}
//protected:
//	int* _p = new int[10];
//};
////  只有派⽣类Student的析构函数重写了Person的析构函数，下⾯的delete对象调⽤析构函数，才能
////	构成多态，才能保证p1和p2指向的对象正确的调⽤析构函数。
//int main()
//{
//	A* p1 = new A;
//	A* p2 = new B;
//	delete p1;
//	delete p2;
//	return 0;
//}



//纯虚函数和抽象类

//class Car//抽象类
//{
//public:
//
//	//1、抽象类不能实例化对象
//	//2、强制子类重写
//	virtual void Drive() = 0;//纯虚函数
//};
//
//
//class Benz :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "Benz-舒适" << endl;
//	}
//};
//
//
//class BMW :public Car
//{
//public:
//	virtual void Drive()
//	{
//		cout << "BMW-操控" << endl;
//	}
//};
//
//
//int main()
//{
//	// 编译报错：error C2259: “Car”: ⽆法实例化抽象类 
//	//Car car;
//	Car* pBenz = new Benz;
//	pBenz->Drive();
//	Car* pBMW = new BMW;
//	pBMW->Drive();
//	return 0;
//}





